home *** CD-ROM | disk | FTP | other *** search
/ What CD? 12 / What PC June 1997.iso / multi / cyber / cyber95 / _setup.1 / RAD1.POP < prev    next >
Encoding:
Text File  |  1996-09-02  |  3.2 KB  |  139 lines
  1. // file : rad1.pop
  2. // the branching algorithm used here is described in Todd & Latham p.151, fig 8.14
  3. // variable names given in brackets corespomd to the names used in Todd & Latham
  4.  
  5.  
  6. population 0
  7. dimensions = 1
  8. colour_model RGB
  9. render_quality flat
  10.  
  11.  
  12.  
  13. genome 0 {
  14.  
  15.     ///////////////////////
  16.     // initialise turtle //
  17.     ///////////////////////
  18.  
  19.     noseUp( 1.570770 ),
  20.     setColour( hsv<.5,.5,.75> : hsv<0,.2,.5> : hsv<.99999,.99999,.99999> ),
  21.     eggScale( 0.75 : 0.2 : 1 ),
  22.  
  23.     //////////////////////////
  24.     // initialise constants //
  25.     //////////////////////////
  26.  
  27.     // generate random constants
  28.     setScalarMem( 5,    2 : 2 : 40 ),        // mem[5] = #ribs
  29.     setScalarMem( 6,    360 : 1 : 360 ),    // mem[6] = angular coverage (= s)
  30.     setScalarMem( 7,    1 : 1 : 1 ),        // mem[7] = diffusion (= p)
  31.  
  32.     // derive surface-coverage from angular coverage, mem[8] = surface-coverage (surfprop)
  33.     setScalarMem( 8,
  34.         mul( 0.5,
  35.             sub( 1,
  36.                 cos( 
  37.                     dtor(
  38.                         mul( 0.5, getScalarMem(6) )
  39.                     ) 
  40.                 )
  41.             )
  42.         )
  43.     ),
  44.  
  45.     // derive number of branches (ncon), mem[9] = #ribs / surface-coverage
  46.     setScalarMem( 9,    div( getScalarMem(5), getScalarMem(8) ) ),
  47.  
  48.  
  49.     /////////////////////////
  50.     // main branching loop //
  51.     /////////////////////////
  52.  
  53.     // for mem[0] = 0 to #ribs - 1
  54.     for( getScalarMem(5),  0,
  55.         join(
  56.             // mem[1] = alpha (m)
  57.             setScalarMem( 1,
  58.                 // NOTE : may need to add 1 to mem[0] before divide!
  59.                 div( getScalarMem(0), getScalarMem(5) )
  60.             ),
  61.  
  62.             // mem[2] = (y) = 1 - 2 * alpha * surface-coverage
  63.             setScalarMem( 2,
  64.                 sub( 1,
  65.                     mul( 2, mul(getScalarMem(1),getScalarMem(9)) )
  66.                 )
  67.             ),
  68.  
  69.             // mem[3] = (phi) = acosd(y)
  70.             setScalarMem( 3,
  71.                 rtod( acos( getScalarMem(2) ) )
  72.             ),
  73.  
  74.             // rotate into position
  75.             noseDown( getScalarMem(3) ),
  76.             swivelLeft(
  77.                 dtor(
  78.                     mul( 137.5, 
  79.                         mul( getScalarMem(7), 
  80.                             mul( getScalarMem(1), getScalarMem(5) ) 
  81.                         ) 
  82.                     )
  83.                 )
  84.             ),
  85.  
  86.             ///////////////////
  87.             // make a branch //
  88.             ///////////////////
  89.  
  90.             scope(
  91.                 // make the reflected helix structure
  92.                 *reflect(
  93.                     <-1,1,1>,
  94.                     repeat(
  95.                         1 : 1 : 60,  // #segments
  96.                         join(
  97.                             // 'lay' a single segment
  98.                             scope(
  99.                                 noseDown( dtor(90 : 45 : 135) ),
  100.                                 // lay the cross-bar
  101.                                 *scope(
  102.                                     setTexture( norder false:toggle ),
  103.                                     setBitmap( norder 0 : 0 : 20 ),
  104.                                     setWrap( norder 0 : 0 : 2 ),
  105.                                     eggVectorScale( <1,1,4> : <1,1,1> : <1,1,8> ),
  106.                                     egg( norder 0 : 0 : 20 ),
  107.                                     moveHue( -0.2 : -0.3 : 0.3 ),
  108.                                     lay
  109.                                 ),
  110.                                 // lay the end-marker
  111.                                 forward( 1 : -2 : 2 ),
  112.                                 egg( norder 0 : 0 : 20 ),
  113.                                 setTexture( norder false:toggle ),
  114.                                 setBitmap( norder 0 : 0 : 20 ),
  115.                                 setWrap( norder 0 : 0 : 2 ),
  116.                                 scope(
  117.                                     rotate( <0,0,0> : <-2,-2,-2> : <2,2,2> ),
  118.                                     forward( 0 : -2 : 2 ),
  119.                                     lay
  120.                                 )
  121.                             ),
  122.                             // inter-segment code
  123.                             *forward( .5 : -1 : 1 ),
  124.                             scale( .95 : .9 : 1.1 ),
  125.                             bankLeft( dtor(10 : -25 : 25) ),
  126.                             moveHue( 0.01 : -0.05 : 0.05 ),
  127.                             moveSat( 0 : -0.05 : 0.05 )
  128.                         )
  129.                     )
  130.                 )
  131.             )
  132.         )  // end main branch code-block
  133.     )  // end main for loop
  134. }
  135.  
  136.  
  137. // eof : rad1.pop
  138.  
  139.